rever traces to normal, handle both in UI

Signed-off-by: Adam Tackett <[email protected]>

Author: Adam Tackett

public/components/trace_analytics/components/traces/traces_content.tsx

@@ -21,7 +21,6 @@ import { coreRefs } from '../../../../framework/core_refs';
 import { handleServiceMapRequest } from '../../requests/services_request_handler';
 import {
   handleCustomIndicesTracesRequest,
-  handleCustomTracesRequest,
   handleTracesRequest,
 } from '../../requests/traces_request_handler';
 import { getValidFilterFields } from '../common/filters/filter_helpers';
@@ -75,38 +74,38 @@ export function TracesContent(props: TracesProps) {
   const [includeMetrics, setIncludeMetrics] = useState(false);
   const isNavGroupEnabled = coreRefs?.chrome?.navGroup.getNavGroupEnabled();
 
-  //ADAM TESITNG DELETE console.log
-  // const defaultSortField = props.tracesTableMode === 'traces' ? 'last_updated' : 'endTime';
-  // const [sortingColumns, setSortingColumns] = useState<{ id: string; direction: "desc" | "asc" }[]>([{ id: defaultSortField, direction: "desc"}]);
-
   const [sortingColumns, setSortingColumns] = useState<{ id: string; direction: "desc" | "asc" }[]>([]);
 
   const [pageIndex, setPageIndex] = useState(0);
   const [pageSize, setPageSize] = useState(10);
 
   const onSort = (sortColumns: { id: string; direction: "desc" | "asc" }[]) => {
-
     if (!sortColumns || sortColumns.length === 0) {
       setSortingColumns([]);
-      refresh(undefined, query, pageIndex, pageSize);
       return;
     }
-
+  
     const sortField = sortColumns[0]?.id;
     const sortDirection = sortColumns[0]?.direction;
-
+  
     if (!sortField || !sortDirection) {
       console.error("Invalid sorting column:", sortColumns);
       return;
     }
-
+  
     setSortingColumns(sortColumns);
-    refresh(
-      { field: sortField, direction: sortDirection },
-      query,
-      pageIndex,
-      pageSize
-    );
+  
+    if (tracesTableMode === 'traces') {
+      const sortedItems = [...tableItems].sort((a, b) => {
+        const valueA = a[sortField];
+        const valueB = b[sortField];
+        return sortDirection === 'asc' ? valueA - valueB : valueB - valueA;
+      });
+  
+      setTableItems(sortedItems);
+    } else {
+      refresh({ field: sortField, direction: sortDirection }, query, pageIndex, pageSize);
+    }
   };
 
   const [totalHits, setTotalHits] = useState(0);
@@ -140,12 +139,20 @@ export function TracesContent(props: TracesProps) {
     pageSizeOptions: [5, 10, 15],
     totalItemCount: totalHits,
     onChangePage: (newPage) => {
-      const { DSL, isUnderOneHour, timeFilterDSL } = generateDSLs();
-      refreshTableDataOnly(newPage, pageSize, DSL, isUnderOneHour, timeFilterDSL);
+      if (tracesTableMode === 'traces') {
+        setPageIndex(newPage);
+      } else {
+        const { DSL, isUnderOneHour, timeFilterDSL } = generateDSLs();
+        refreshTableDataOnly(newPage, pageSize, DSL, isUnderOneHour, timeFilterDSL);
+      }
     },
     onChangeItemsPerPage: (newSize) => {
-      const { DSL, isUnderOneHour, timeFilterDSL } = generateDSLs();
-      refreshTableDataOnly(0, newSize, DSL, isUnderOneHour, timeFilterDSL);
+      if (tracesTableMode === 'traces') {
+        setPageSize(newSize);
+      } else {
+        const { DSL, isUnderOneHour, timeFilterDSL } = generateDSLs();
+        refreshTableDataOnly(0, newSize, DSL, isUnderOneHour, timeFilterDSL);
+      }
     },
   };
 
@@ -231,39 +238,21 @@ export function TracesContent(props: TracesProps) {
       ? { field: sortingColumns[0].id, direction: sortingColumns[0].direction }
       : undefined;
 
-    const tracesRequest =
-      tracesTableMode !== 'traces'
-        ? handleCustomIndicesTracesRequest(
-            http,
-            DSL,
-            tableItems,
-            setTableItems,
-            setColumns,
-            mode,
-            newPageIndex,
-            newPageSize,
-            setTotalHits,
-            props.dataSourceMDSId[0]?.id,
-            sortParams,
-            tracesTableMode,
-            isUnderOneHour
-          )
-        : handleCustomTracesRequest(
-            http,
-            DSL,
-            timeFilterDSL,
-            tableItems,
-            setTableItems,
-            setTotalHits,
-            mode,
-            newPageIndex,
-            newPageSize,
-            props.dataSourceMDSId[0]?.id,
-            sortParams,
-            isUnderOneHour
-          );
-  
-    tracesRequest.finally(() => setIsTraceTableLoading(false));
+    handleCustomIndicesTracesRequest(
+      http,
+      DSL,
+      tableItems,
+      setTableItems,
+      setColumns,
+      mode,
+      newPageIndex,
+      newPageSize,
+      setTotalHits,
+      props.dataSourceMDSId[0]?.id,
+      sortParams,
+      tracesTableMode,
+      isUnderOneHour
+    ).finally(() => setIsTraceTableLoading(false));
   };
 
   const refresh = async (
@@ -318,17 +307,14 @@ export function TracesContent(props: TracesProps) {
             tracesTableMode,
             isUnderOneHour
           )
-          : handleCustomTracesRequest(
+          : handleTracesRequest(
             http,
             DSL,
             timeFilterDSL,
             tableItems,
             setTableItems,
-            setTotalHits,
             mode,
-            pageIndex,
-            pageSize,
-            props.dataSourceMDSId[0]?.id,
+            props.dataSourceMDSId[0].id,
             sort,
             isUnderOneHour
           );

public/components/trace_analytics/components/traces/traces_custom_indices_table.tsx

@@ -61,12 +61,14 @@ export function TracesCustomIndicesTable(props: TracesLandingTableProps) {
 
   const renderCellValue = useMemo(() => {
     return ({ rowIndex, columnId }: { rowIndex: number; columnId: string }) => {
-      const adjustedRowIndex = rowIndex - pagination.pageIndex * pagination.pageSize;
+      const isTracesMode = props.tracesTableMode === 'traces';
+      const adjustedRowIndex = isTracesMode ? rowIndex : rowIndex - pagination.pageIndex * pagination.pageSize;
+      
       if (!items.hasOwnProperty(adjustedRowIndex)) return '-';
       const value = items[adjustedRowIndex]?.[columnId];
-
+  
       if (!value && columnId !== 'status.code' && columnId !== 'error_count') return '-';
-
+  
       switch (columnId) {
         case 'endTime':
           return moment(value).format('MM/DD/YYYY HH:mm:ss.SSS');
@@ -85,17 +87,18 @@ export function TracesCustomIndicesTable(props: TracesLandingTableProps) {
           ) : (
             'No'
           );
-          case 'error_count':
-            return value > 0 ? (
-              <EuiText color="danger" size="s">Yes</EuiText>
-            ) : (
-              'No'
-            );
+        case 'error_count':
+          return value > 0 ? (
+            <EuiText color="danger" size="s">Yes</EuiText>
+          ) : (
+            'No'
+          );
         default:
           return value;
       }
     };
-  }, [items, pagination.pageIndex, pagination.pageSize]);
+  }, [items, pagination.pageIndex, pagination.pageSize, props.tracesTableMode]);
+  
 
   const columns = useMemo(() => {
     return getTableColumns(
@@ -132,7 +135,7 @@ export function TracesCustomIndicesTable(props: TracesLandingTableProps) {
             key={columns.map(col => col.id).join('-')}//Force re-render for switching from spans to traces
             columns={columns}
             renderCellValue={renderCellValue}
-            rowCount={totalHits}
+            rowCount={props.tracesTableMode === 'traces' ? items.length : totalHits}
             sorting={{ columns: sortingColumns, onSort }}
             pagination={pagination}
             isTableDataLoading={loading}

public/components/trace_analytics/requests/queries/traces_queries.ts

@@ -194,152 +194,6 @@ export const getTracesQuery = (
   return mode === 'jaeger' ? jaegerQuery : dataPrepperQuery;
 };
 
-export const getCustomTracesQuery = (
-  mode: TraceAnalyticsMode,
-  from: number,
-  size: number,
-  traceId: string = '',
-  sort?: PropertySort,
-  isUnderOneHour?: boolean
-) => {
-  const field = sort?.field || '_key';
-  const direction = sort?.direction || 'asc';
-
-  const jaegerQuery: any = {
-    size,
-    from,
-    query: {
-      bool: {
-        must: [],
-        filter: [],
-        should: [],
-        must_not: [],
-      },
-    },
-    aggs: {
-      traces: {
-        terms: {
-          field: 'traceID',
-          size,
-          order: {
-            [field]: direction,
-          },
-          ...(isUnderOneHour && { execution_hint: 'map' }),
-        },
-        aggs: {
-          latency: {
-            max: {
-              script: {
-                source: `
-                if (doc.containsKey('duration') && !doc['duration'].empty) {
-                  return Math.round(doc['duration'].value) / 1000.0
-                }
-                return 0
-                `,
-                lang: 'painless',
-              },
-            },
-          },
-          trace_group: {
-            terms: {
-              field: 'traceGroup',
-              size: 1,
-            },
-          },
-          error_count: {
-            filter: {
-              term: {
-                'tag.error': true,
-              },
-            },
-          },
-          last_updated: {
-            max: {
-              script: {
-                source: `
-                if (doc.containsKey('startTime') && !doc['startTime'].empty && doc.containsKey('duration') && !doc['duration'].empty) {
-                  return (Math.round(doc['duration'].value) + Math.round(doc['startTime'].value)) / 1000.0
-                }
-                return 0
-                `,
-                lang: 'painless',
-              },
-            },
-          },
-        },
-      },
-    },
-    track_total_hits: true,
-  };
-
-  const dataPrepperQuery: any = {
-    size,
-    from,
-    query: {
-      bool: {
-        must: [],
-        filter: [],
-        should: [],
-        must_not: [],
-      },
-    },
-    aggs: {
-      traces: {
-        terms: {
-          field: 'traceId',
-          size,
-          order: {
-            [field]: direction,
-          },
-          ...(isUnderOneHour && { execution_hint: 'map' }),
-        },
-        aggs: {
-          latency: {
-            max: {
-              script: {
-                source: `
-                if (doc.containsKey('traceGroupFields.durationInNanos') && !doc['traceGroupFields.durationInNanos'].empty) {
-                  return Math.round(doc['traceGroupFields.durationInNanos'].value / 10000) / 100.0
-                }
-                return 0
-                `,
-                lang: 'painless',
-              },
-            },
-          },
-          trace_group: {
-            terms: {
-              field: 'traceGroup',
-              size: 1,
-            },
-          },
-          error_count: {
-            filter: {
-              term: {
-                'traceGroupFields.statusCode': '2',
-              },
-            },
-          },
-          last_updated: {
-            max: {
-              field: 'traceGroupFields.endTime',
-            },
-          },
-        },
-      },
-    },
-    track_total_hits: true,
-  };
-
-  if (traceId) {
-    jaegerQuery.query.bool.filter.push({ term: { traceID: traceId } });
-    dataPrepperQuery.query.bool.filter.push({ term: { traceId } });
-  }
-
-  return mode === 'jaeger' ? jaegerQuery : dataPrepperQuery;
-};
-
-
 export const getPayloadQuery = (mode: TraceAnalyticsMode, traceId: string, size = 3000) => {
   if (mode === 'jaeger') {
     return {