@oneuptime/common 10.5.1 → 10.5.2

package/Server/Utils/Telemetry/ResourceFacetResolver.ts

@@ -0,0 +1,299 @@
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import Search from "../../../Types/BaseDatabase/Search";
+import MultiSearch from "../../../Types/BaseDatabase/MultiSearch";
+import ServiceModel from "../../../Models/DatabaseModels/Service";
+import HostModel from "../../../Models/DatabaseModels/Host";
+import DockerHostModel from "../../../Models/DatabaseModels/DockerHost";
+import KubernetesClusterModel from "../../../Models/DatabaseModels/KubernetesCluster";
+import ServiceService from "../../Services/ServiceService";
+import HostService from "../../Services/HostService";
+import DockerHostService from "../../Services/DockerHostService";
+import KubernetesClusterService from "../../Services/KubernetesClusterService";
+import CaptureSpan from "./CaptureSpan";
+
+/*
+ * Facet keys whose values are entity IDs backed by a Postgres source-of-truth
+ * table. ClickHouse aggregation only sees IDs that appear in the sampled
+ * trace/log window, so low-volume resources never reach the filter sidebar.
+ * Resolving the value list from Postgres instead means every project resource
+ * shows up regardless of recent telemetry activity, and the sidebar search
+ * matches across the full set (not just the loaded subset).
+ */
+export const RESOURCE_FACET_KEYS: ReadonlySet<string> = new Set([
+  "serviceId",
+  "hostId",
+  "dockerHostId",
+  "kubernetesClusterId",
+]);
+
+export interface ResourceFacetSpec {
+  facetKey: string;
+  counts: Map<string, number>;
+  searchText?: string | undefined;
+  limit?: number | undefined;
+}
+
+export interface ResolvedFacetValue {
+  value: string;
+  count: number;
+  displayName: string;
+}
+
+export default class ResourceFacetResolver {
+  private static readonly DEFAULT_LIMIT: number = 500;
+
+  public static isResourceFacet(facetKey: string): boolean {
+    return RESOURCE_FACET_KEYS.has(facetKey);
+  }
+
+  @CaptureSpan()
+  public static async resolve(
+    projectId: ObjectID,
+    specs: Array<ResourceFacetSpec>,
+  ): Promise<Record<string, Array<ResolvedFacetValue>>> {
+    const results: Array<readonly [string, Array<ResolvedFacetValue>]> =
+      await Promise.all(
+        specs.map(
+          async (
+            spec: ResourceFacetSpec,
+          ): Promise<readonly [string, Array<ResolvedFacetValue>]> => {
+            try {
+              const values: Array<ResolvedFacetValue> =
+                await ResourceFacetResolver.resolveOne(projectId, spec);
+              return [spec.facetKey, values] as const;
+            } catch {
+              return [spec.facetKey, []] as const;
+            }
+          },
+        ),
+      );
+
+    return Object.fromEntries(results);
+  }
+
+  private static async resolveOne(
+    projectId: ObjectID,
+    spec: ResourceFacetSpec,
+  ): Promise<Array<ResolvedFacetValue>> {
+    const limit: number = spec.limit ?? ResourceFacetResolver.DEFAULT_LIMIT;
+    const searchText: string | undefined =
+      spec.searchText && spec.searchText.trim().length > 0
+        ? spec.searchText.trim()
+        : undefined;
+
+    switch (spec.facetKey) {
+      case "serviceId":
+        return ResourceFacetResolver.queryServices(
+          projectId,
+          spec.counts,
+          searchText,
+          limit,
+        );
+      case "hostId":
+        return ResourceFacetResolver.queryHosts(
+          projectId,
+          spec.counts,
+          searchText,
+          limit,
+        );
+      case "dockerHostId":
+        return ResourceFacetResolver.queryDockerHosts(
+          projectId,
+          spec.counts,
+          searchText,
+          limit,
+        );
+      case "kubernetesClusterId":
+        return ResourceFacetResolver.queryKubernetesClusters(
+          projectId,
+          spec.counts,
+          searchText,
+          limit,
+        );
+      default:
+        return [];
+    }
+  }
+
+  private static async queryServices(
+    projectId: ObjectID,
+    counts: Map<string, number>,
+    searchText: string | undefined,
+    limit: number,
+  ): Promise<Array<ResolvedFacetValue>> {
+    const query: Record<string, unknown> = { projectId };
+    if (searchText) {
+      query["name"] = new Search<string>(searchText);
+    }
+
+    const services: Array<ServiceModel> = await ServiceService.findBy({
+      query: query as any,
+      select: {
+        _id: true,
+        name: true,
+      },
+      limit: new PositiveNumber(limit),
+      skip: new PositiveNumber(0),
+      props: { isRoot: true },
+    });
+
+    return ResourceFacetResolver.mergeCounts(
+      services.map((s: ServiceModel): { id: string; displayName: string } => {
+        return {
+          id: s._id ? s._id.toString() : "",
+          displayName: s.name || "Unknown",
+        };
+      }),
+      counts,
+    );
+  }
+
+  private static async queryHosts(
+    projectId: ObjectID,
+    counts: Map<string, number>,
+    searchText: string | undefined,
+    limit: number,
+  ): Promise<Array<ResolvedFacetValue>> {
+    const query: Record<string, unknown> = { projectId };
+    if (searchText) {
+      query["name"] = new MultiSearch({
+        fields: ["name", "hostIdentifier"],
+        value: searchText,
+      });
+    }
+
+    const hosts: Array<HostModel> = await HostService.findBy({
+      query: query as any,
+      select: {
+        _id: true,
+        name: true,
+        hostIdentifier: true,
+      },
+      limit: new PositiveNumber(limit),
+      skip: new PositiveNumber(0),
+      props: { isRoot: true },
+    });
+
+    return ResourceFacetResolver.mergeCounts(
+      hosts.map((h: HostModel): { id: string; displayName: string } => {
+        return {
+          id: h._id ? h._id.toString() : "",
+          displayName: h.name || h.hostIdentifier || "Unknown",
+        };
+      }),
+      counts,
+    );
+  }
+
+  private static async queryDockerHosts(
+    projectId: ObjectID,
+    counts: Map<string, number>,
+    searchText: string | undefined,
+    limit: number,
+  ): Promise<Array<ResolvedFacetValue>> {
+    const query: Record<string, unknown> = { projectId };
+    if (searchText) {
+      query["name"] = new MultiSearch({
+        fields: ["name", "hostIdentifier"],
+        value: searchText,
+      });
+    }
+
+    const dockerHosts: Array<DockerHostModel> = await DockerHostService.findBy({
+      query: query as any,
+      select: {
+        _id: true,
+        name: true,
+        hostIdentifier: true,
+      },
+      limit: new PositiveNumber(limit),
+      skip: new PositiveNumber(0),
+      props: { isRoot: true },
+    });
+
+    return ResourceFacetResolver.mergeCounts(
+      dockerHosts.map(
+        (d: DockerHostModel): { id: string; displayName: string } => {
+          return {
+            id: d._id ? d._id.toString() : "",
+            displayName: d.name || d.hostIdentifier || "Unknown",
+          };
+        },
+      ),
+      counts,
+    );
+  }
+
+  private static async queryKubernetesClusters(
+    projectId: ObjectID,
+    counts: Map<string, number>,
+    searchText: string | undefined,
+    limit: number,
+  ): Promise<Array<ResolvedFacetValue>> {
+    const query: Record<string, unknown> = { projectId };
+    if (searchText) {
+      query["name"] = new MultiSearch({
+        fields: ["name", "clusterIdentifier"],
+        value: searchText,
+      });
+    }
+
+    const clusters: Array<KubernetesClusterModel> =
+      await KubernetesClusterService.findBy({
+        query: query as any,
+        select: {
+          _id: true,
+          name: true,
+          clusterIdentifier: true,
+        },
+        limit: new PositiveNumber(limit),
+        skip: new PositiveNumber(0),
+        props: { isRoot: true },
+      });
+
+    return ResourceFacetResolver.mergeCounts(
+      clusters.map(
+        (c: KubernetesClusterModel): { id: string; displayName: string } => {
+          return {
+            id: c._id ? c._id.toString() : "",
+            displayName: c.name || c.clusterIdentifier || "Unknown",
+          };
+        },
+      ),
+      counts,
+    );
+  }
+
+  /*
+   * Combine Postgres-sourced entities with counts from the ClickHouse sample.
+   * Entities without a count default to 0 (they exist in the project but
+   * had no telemetry in the active window). Sorts active-first so the
+   * highest-traffic resources surface at the top of the sidebar.
+   */
+  private static mergeCounts(
+    entities: Array<{ id: string; displayName: string }>,
+    counts: Map<string, number>,
+  ): Array<ResolvedFacetValue> {
+    const out: Array<ResolvedFacetValue> = entities
+      .filter((e: { id: string }): boolean => {
+        return e.id.length > 0;
+      })
+      .map((e: { id: string; displayName: string }): ResolvedFacetValue => {
+        return {
+          value: e.id,
+          count: counts.get(e.id) || 0,
+          displayName: e.displayName,
+        };
+      });
+
+    out.sort((a: ResolvedFacetValue, b: ResolvedFacetValue): number => {
+      if (a.count !== b.count) {
+        return b.count - a.count;
+      }
+      return a.displayName.localeCompare(b.displayName);
+    });
+
+    return out;
+  }
+}

package/UI/Components/LogsViewer/LogsViewer.tsx

@@ -89,6 +89,15 @@ export interface ComponentProps {
   facetLoading?: boolean;
   onFacetInclude?: (facetKey: string, value: string) => void;
   onFacetExclude?: (facetKey: string, value: string) => void;
+  /*
+   * Debounced search emit for resource facets (serviceId / hostId / etc.).
+   * Parent updates state and re-fetches facets so the result includes
+   * matching resources from the Postgres source-of-truth, not just those
+   * already loaded into the sidebar.
+   */
+  onFacetSearchChange?:
+    | ((facetKey: string, searchText: string) => void)
+    | undefined;
   showFacetSidebar?: boolean;
   activeFilters?: Array<ActiveFilter> | undefined;
   baseActiveFilters?: Array<ActiveFilter> | undefined;
@@ -1063,6 +1072,7 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
               savedViews={props.savedViews}
               selectedSavedViewId={props.selectedSavedViewId}
               onSavedViewSelect={props.onSavedViewSelect}
+              onFacetSearchChange={props.onFacetSearchChange}
             />
           )}
 

package/UI/Components/LogsViewer/components/FacetSection.tsx

@@ -1,6 +1,8 @@
 import React, {
   FunctionComponent,
   ReactElement,
+  useEffect,
+  useRef,
   useState,
   useMemo,
 } from "react";
@@ -19,10 +21,17 @@ export interface FacetSectionProps {
   valueDisplayMap?: Record<string, string> | undefined;
   valueColorMap?: Record<string, string> | undefined;
   activeValues?: Set<string> | undefined;
+  /*
+   * When set, the search box also emits typed text to the parent (debounced)
+   * so it can refetch values from the backend. Client-side filtering still
+   * runs as defense-in-depth.
+   */
+  onSearchChange?: ((text: string) => void) | undefined;
 }
 
 const DEFAULT_VISIBLE_COUNT: number = 5;
 const SEARCH_THRESHOLD: number = 6;
+const SEARCH_DEBOUNCE_MS: number = 300;
 
 const FacetSection: FunctionComponent<FacetSectionProps> = (
   props: FacetSectionProps,
@@ -31,7 +40,31 @@ const FacetSection: FunctionComponent<FacetSectionProps> = (
   const [showAll, setShowAll] = useState<boolean>(false);
   const [searchText, setSearchText] = useState<string>("");
 
-  const showSearch: boolean = props.values.length >= SEARCH_THRESHOLD;
+  const showSearch: boolean =
+    props.onSearchChange !== undefined ||
+    props.values.length >= SEARCH_THRESHOLD;
+
+  const onSearchChange: FacetSectionProps["onSearchChange"] =
+    props.onSearchChange;
+  const lastEmittedRef: React.MutableRefObject<string | null> = useRef<
+    string | null
+  >(null);
+  useEffect(() => {
+    if (!onSearchChange) {
+      return;
+    }
+    const trimmed: string = searchText.trim();
+    if (lastEmittedRef.current === trimmed) {
+      return;
+    }
+    const handle: ReturnType<typeof setTimeout> = setTimeout(() => {
+      lastEmittedRef.current = trimmed;
+      onSearchChange(trimmed);
+    }, SEARCH_DEBOUNCE_MS);
+    return () => {
+      clearTimeout(handle);
+    };
+  }, [searchText, onSearchChange]);
 
   const filteredValues: Array<FacetValue> = useMemo(() => {
     if (!searchText.trim()) {
@@ -40,7 +73,9 @@ const FacetSection: FunctionComponent<FacetSectionProps> = (
     const query: string = searchText.toLowerCase().trim();
     return props.values.filter((facet: FacetValue) => {
       const displayName: string =
-        props.valueDisplayMap?.[facet.value] ?? facet.value;
+        facet.displayName ??
+        props.valueDisplayMap?.[facet.value] ??
+        facet.value;
       return displayName.toLowerCase().includes(query);
     });
   }, [props.values, props.valueDisplayMap, searchText]);
@@ -114,7 +149,9 @@ const FacetSection: FunctionComponent<FacetSectionProps> = (
               <FacetValueRow
                 key={facet.value}
                 value={facet.value}
-                displayValue={props.valueDisplayMap?.[facet.value]}
+                displayValue={
+                  facet.displayName ?? props.valueDisplayMap?.[facet.value]
+                }
                 count={facet.count}
                 maxCount={maxCount}
                 color={props.valueColorMap?.[facet.value]}

package/UI/Components/LogsViewer/components/LogsFacetSidebar.tsx

@@ -28,8 +28,23 @@ export interface LogsFacetSidebarProps {
   savedViews?: Array<LogsSavedViewOption> | undefined;
   selectedSavedViewId?: string | null | undefined;
   onSavedViewSelect?: ((viewId: string) => void) | undefined;
+  /*
+   * Called (debounced) when typing in a resource facet's search box. Lets
+   * the parent re-issue the facets request with the typed text scoped to
+   * that facet, so the result includes resources beyond the loaded subset.
+   */
+  onFacetSearchChange?:
+    | ((facetKey: string, searchText: string) => void)
+    | undefined;
 }
 
+const RESOURCE_FACET_KEYS: ReadonlySet<string> = new Set([
+  "serviceId",
+  "hostId",
+  "dockerHostId",
+  "kubernetesClusterId",
+]);
+
 const SEVERITY_ORDER: Array<string> = [
   LogSeverity.Fatal,
   LogSeverity.Error,
@@ -278,6 +293,13 @@ const LogsFacetSidebar: FunctionComponent<LogsFacetSidebarProps> = (
             valueColorMap = severityColorMap;
           }
 
+          const onSearchChange: ((text: string) => void) | undefined =
+            RESOURCE_FACET_KEYS.has(key) && props.onFacetSearchChange
+              ? (text: string) => {
+                  props.onFacetSearchChange!(key, text);
+                }
+              : undefined;
+
           return (
             <FacetSection
               key={key}
@@ -289,6 +311,7 @@ const LogsFacetSidebar: FunctionComponent<LogsFacetSidebarProps> = (
               valueDisplayMap={valueDisplayMap}
               valueColorMap={valueColorMap}
               activeValues={activeValuesByKey[key]}
+              onSearchChange={onSearchChange}
             />
           );
         })}

package/UI/Components/LogsViewer/types.ts

@@ -13,6 +13,8 @@ export interface HistogramBucket {
 export interface FacetValue {
   value: string;
   count: number;
+  // Server-resolved display name (e.g. serviceId → service name).
+  displayName?: string | undefined;
 }
 
 export type FacetData = Record<string, Array<FacetValue>>;

package/UI/Components/TelemetryViewer/TelemetryViewer.tsx

@@ -70,6 +70,13 @@ export interface TelemetryViewerProps<T> {
   facetLoading?: boolean;
   onFacetInclude?: ((facetKey: string, value: string) => void) | undefined;
   onFacetExclude?: ((facetKey: string, value: string) => void) | undefined;
+  /*
+   * Called (debounced) when the user types in a server-searchable facet's
+   * search box. Parent typically updates state and refetches facetData.
+   */
+  onFacetSearchChange?:
+    | ((facetKey: string, searchText: string) => void)
+    | undefined;
 
   // -- Active filters --
   activeFilters?: Array<ActiveFilter> | undefined;
@@ -219,6 +226,7 @@ function TelemetryViewerInner<T>(props: TelemetryViewerProps<T>): ReactElement {
             onExcludeFilter={(key: string, value: string) => {
               props.onFacetExclude?.(key, value);
             }}
+            onFacetSearchChange={props.onFacetSearchChange}
           />
         )}
 

package/UI/Components/TelemetryViewer/components/TelemetryFacetSection.tsx

@@ -1,6 +1,8 @@
 import React, {
   FunctionComponent,
   ReactElement,
+  useEffect,
+  useRef,
   useState,
   useMemo,
 } from "react";
@@ -20,10 +22,20 @@ export interface TelemetryFacetSectionProps {
   valueColorMap?: Record<string, string> | undefined;
   activeValues?: Set<string> | undefined;
   defaultExpanded?: boolean;
+  /*
+   * When set, the search box also emits typed text to the parent (debounced)
+   * so it can refetch values from the backend. Client-side filtering still
+   * runs as defense-in-depth — the server response replaces props.values
+   * which then flows through the local filter.
+   */
+  onSearchChange?: ((text: string) => void) | undefined;
+  // Force the search input to render even when below the local item threshold.
+  alwaysShowSearch?: boolean;
 }
 
 const DEFAULT_VISIBLE_COUNT: number = 5;
 const SEARCH_THRESHOLD: number = 6;
+const SEARCH_DEBOUNCE_MS: number = 300;
 
 const TelemetryFacetSection: FunctionComponent<TelemetryFacetSectionProps> = (
   props: TelemetryFacetSectionProps,
@@ -34,7 +46,37 @@ const TelemetryFacetSection: FunctionComponent<TelemetryFacetSectionProps> = (
   const [showAll, setShowAll] = useState<boolean>(false);
   const [searchText, setSearchText] = useState<string>("");
 
-  const showSearch: boolean = props.values.length >= SEARCH_THRESHOLD;
+  const showSearch: boolean =
+    props.alwaysShowSearch === true ||
+    props.onSearchChange !== undefined ||
+    props.values.length >= SEARCH_THRESHOLD;
+
+  /*
+   * Debounce the upward search emit so each keystroke doesn't fire a
+   * round-trip. Local filter still applies immediately for fast feedback
+   * against the currently loaded set.
+   */
+  const onSearchChange: TelemetryFacetSectionProps["onSearchChange"] =
+    props.onSearchChange;
+  const lastEmittedRef: React.MutableRefObject<string | null> = useRef<
+    string | null
+  >(null);
+  useEffect(() => {
+    if (!onSearchChange) {
+      return;
+    }
+    const trimmed: string = searchText.trim();
+    if (lastEmittedRef.current === trimmed) {
+      return;
+    }
+    const handle: ReturnType<typeof setTimeout> = setTimeout(() => {
+      lastEmittedRef.current = trimmed;
+      onSearchChange(trimmed);
+    }, SEARCH_DEBOUNCE_MS);
+    return () => {
+      clearTimeout(handle);
+    };
+  }, [searchText, onSearchChange]);
 
   const filteredValues: Array<FacetValue> = useMemo(() => {
     if (!searchText.trim()) {
@@ -43,7 +85,9 @@ const TelemetryFacetSection: FunctionComponent<TelemetryFacetSectionProps> = (
     const query: string = searchText.toLowerCase().trim();
     return props.values.filter((facet: FacetValue) => {
       const displayName: string =
-        props.valueDisplayMap?.[facet.value] ?? facet.value;
+        facet.displayName ??
+        props.valueDisplayMap?.[facet.value] ??
+        facet.value;
       return displayName.toLowerCase().includes(query);
     });
   }, [props.values, props.valueDisplayMap, searchText]);
@@ -117,7 +161,9 @@ const TelemetryFacetSection: FunctionComponent<TelemetryFacetSectionProps> = (
               <TelemetryFacetValueRow
                 key={facet.value}
                 value={facet.value}
-                displayValue={props.valueDisplayMap?.[facet.value]}
+                displayValue={
+                  facet.displayName ?? props.valueDisplayMap?.[facet.value]
+                }
                 count={facet.count}
                 maxCount={maxCount}
                 color={props.valueColorMap?.[facet.value]}

package/UI/Components/TelemetryViewer/components/TelemetryFacetSidebar.tsx

@@ -12,6 +12,14 @@ export interface TelemetryFacetSidebarProps {
   onExcludeFilter: (facetKey: string, value: string) => void;
   activeFilters?: Array<ActiveFilter> | undefined;
   headerLabel?: string | undefined;
+  /*
+   * Called (debounced) when a search input changes for a facet whose config
+   * has serverSearchable=true. Lets the parent re-issue a facets request
+   * with the typed text scoped to that facet.
+   */
+  onFacetSearchChange?:
+    | ((facetKey: string, searchText: string) => void)
+    | undefined;
 }
 
 const TelemetryFacetSidebar: FunctionComponent<TelemetryFacetSidebarProps> = (
@@ -63,6 +71,13 @@ const TelemetryFacetSidebar: FunctionComponent<TelemetryFacetSidebarProps> = (
         {orderedConfigs.map((config: FacetConfig) => {
           const values: Array<FacetValue> = props.facetData[config.key] || [];
 
+          const onSearchChange: ((text: string) => void) | undefined =
+            config.serverSearchable && props.onFacetSearchChange
+              ? (text: string) => {
+                  props.onFacetSearchChange!(config.key, text);
+                }
+              : undefined;
+
           return (
             <TelemetryFacetSection
               key={config.key}
@@ -74,6 +89,7 @@ const TelemetryFacetSidebar: FunctionComponent<TelemetryFacetSidebarProps> = (
               valueDisplayMap={config.valueDisplayMap}
               valueColorMap={config.valueColorMap}
               activeValues={activeValuesByKey[config.key]}
+              onSearchChange={onSearchChange}
             />
           );
         })}

package/UI/Components/TelemetryViewer/types.ts

@@ -6,6 +6,12 @@
 export interface FacetValue {
   value: string;
   count: number;
+  /*
+   * Optional server-resolved display name. Set by the backend when the facet
+   * value is resolved against a source-of-truth table (e.g. serviceId →
+   * service name). Falls back to the parent's valueDisplayMap if not present.
+   */
+  displayName?: string | undefined;
 }
 
 export type FacetData = Record<string, Array<FacetValue>>;
@@ -52,6 +58,12 @@ export interface FacetConfig {
   valueColorMap?: Record<string, string> | undefined;
   // Ordering priority: lower = shown first.
   priority?: number | undefined;
+  /*
+   * When true, the section's search box also emits typed text to the
+   * sidebar's `onFacetSearchChange` callback so the parent can refetch
+   * values from the backend (used for resource facets backed by Postgres).
+   */
+  serverSearchable?: boolean | undefined;
 }
 
 export interface SearchHelpRow {

package/build/dist/Models/DatabaseModels/TelemetryException.js

@@ -1264,6 +1264,17 @@ TelemetryException = __decorate([
         name: "TelemetryException",
     }),
     Index(["projectId", "isResolved", "isArchived"]) // Exceptions dashboard counts/filters
+    /*
+     * Composite uniqueness on the dedup key used by the OTel traces ingest
+     * batched upsert. The ingest path collapses every exception event in a
+     * worker batch into a single INSERT … ON CONFLICT (projectId,
+     * serviceId, fingerprint) DO UPDATE statement; this index is what makes
+     * that conflict target resolvable and stops two concurrent workers from
+     * racing the old findOneBy + update path into duplicate rows or lost
+     * occuranceCount increments.
+     */
+    ,
+    Index(["projectId", "serviceId", "fingerprint"], { unique: true })
 ], TelemetryException);
 export default TelemetryException;
 //# sourceMappingURL=TelemetryException.js.map