@oneuptime/common 10.5.9 → 10.5.18

package/Server/Utils/Telemetry.ts

@@ -39,7 +39,11 @@ import {
 } from "@opentelemetry/sdk-metrics";
 import type { PushMetricExporter } from "@opentelemetry/sdk-metrics/build/src/export/MetricExporter";
 import * as opentelemetry from "@opentelemetry/sdk-node";
-import { SpanExporter } from "@opentelemetry/sdk-trace-base";
+import {
+  BatchSpanProcessor,
+  SpanExporter,
+  SpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
 import {
   ATTR_SERVICE_NAME,
   ATTR_SERVICE_VERSION,
@@ -48,6 +52,8 @@ import URL from "../../Types/API/URL";
 import Dictionary from "../../Types/Dictionary";
 import { AppVersion, Env, DisableTelemetry } from "../EnvironmentConfig";
 import logger from "./Logger";
+import GracefulShutdown, { ShutdownPriority } from "./GracefulShutdown";
+import ContextSpanProcessor from "./Telemetry/ContextSpanProcessor";
 import RuntimeMetrics from "./Telemetry/RuntimeMetrics";
 
 type ResourceWithRawAttributes = LogsResource & {
@@ -268,10 +274,21 @@ export default class Telemetry {
           autoDetectResources: true,
         };
 
+      /*
+       * Always run the ContextSpanProcessor so the ambient TelemetryContext
+       * attributes (projectId, userId, monitorId, incidentId, requestId, ...)
+       * are stamped onto every span at creation. The BatchSpanProcessor that
+       * actually exports spans is added after it, and only when an exporter is
+       * configured. (traceExporter is deprecated in favour of spanProcessors.)
+       */
+      const spanProcessors: Array<SpanProcessor> = [new ContextSpanProcessor()];
+
       if (traceExporter) {
-        nodeSdkConfiguration.traceExporter = traceExporter;
+        spanProcessors.push(new BatchSpanProcessor(traceExporter));
       }
 
+      nodeSdkConfiguration.spanProcessors = spanProcessors;
+
       /*
        * We will skip this becasue we're attachng this metric reader to the meter provider later.
        * if (this.metricReader) {
@@ -294,11 +311,20 @@ export default class Telemetry {
       this.getMeterProvider();
       this.getMeter();
 
-      process.on("SIGTERM", () => {
-        sdk.shutdown().finally(() => {
-          return process.exit(0);
-        });
-      });
+      /*
+       * Flush traces / metrics / logs last (Telemetry tier) so spans and logs
+       * emitted by the rest of the shutdown still get exported. GracefulShutdown
+       * owns process.exit now — this handler must NOT call it itself, or it
+       * would race the other tiers and abandon the datastore pools (the exact
+       * bug this replaced).
+       */
+      GracefulShutdown.registerHandler(
+        "Telemetry",
+        ShutdownPriority.Telemetry,
+        () => {
+          return sdk.shutdown();
+        },
+      );
 
       sdk.start();
 

package/Tests/Server/Services/TelemetryAttributeService.test.ts

@@ -0,0 +1,83 @@
+import { TelemetryAttributeService } from "../../../Server/Services/TelemetryAttributeService";
+import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test } from "@jest/globals";
+
+describe("TelemetryAttributeService.buildAttributeValuesStatement", () => {
+  /*
+   * Only the column/table names are read while building the statement, so a
+   * lightweight source literal is enough — no real AnalyticsDatabaseService.
+   */
+  const source: unknown = {
+    tableName: "MetricItemV2",
+    attributesColumn: "attributes",
+    attributeKeysColumn: "attributeKeys",
+    timeColumn: "time",
+  };
+
+  type BuildInput = {
+    projectId: ObjectID;
+    source: unknown;
+    metricName?: string | undefined;
+    attributeKey: string;
+    searchText?: string | undefined;
+  };
+
+  const buildValuesStatement: (overrides?: Partial<BuildInput>) => Statement = (
+    overrides: Partial<BuildInput> = {},
+  ): Statement => {
+    return (
+      TelemetryAttributeService as unknown as {
+        buildAttributeValuesStatement: (data: BuildInput) => Statement;
+      }
+    ).buildAttributeValuesStatement({
+      projectId: ObjectID.generate(),
+      source,
+      attributeKey: "host.name",
+      ...overrides,
+    });
+  };
+
+  test("omits the ILIKE filter when no search text is provided", () => {
+    const statement: Statement = buildValuesStatement();
+
+    expect(statement.query).not.toContain("ILIKE");
+    expect(statement.query).toContain("ORDER BY attributeValue ASC");
+  });
+
+  test("omits the ILIKE filter when search text is only whitespace", () => {
+    const statement: Statement = buildValuesStatement({ searchText: "   " });
+
+    expect(statement.query).not.toContain("ILIKE");
+  });
+
+  test("adds a case-insensitive substring filter when search text is provided", () => {
+    const statement: Statement = buildValuesStatement({ searchText: "web" });
+
+    expect(statement.query).toContain("ILIKE");
+    // The value is parameterized and wrapped with % wildcards.
+    expect(Object.values(statement.query_params)).toContain("%web%");
+    // The attribute key is always parameterized — never inlined into SQL.
+    expect(Object.values(statement.query_params)).toContain("host.name");
+  });
+
+  test("trims surrounding whitespace from the search text", () => {
+    const statement: Statement = buildValuesStatement({
+      searchText: "  web-server  ",
+    });
+
+    expect(Object.values(statement.query_params)).toContain("%web-server%");
+  });
+
+  test("scopes to a metric when metricName is provided", () => {
+    const statement: Statement = buildValuesStatement({
+      metricName: "http.server.duration",
+      searchText: "web",
+    });
+
+    expect(statement.query).toContain("AND name =");
+    expect(Object.values(statement.query_params)).toContain(
+      "http.server.duration",
+    );
+  });
+});

package/Types/Database/AccessControl/OwnedThrough.ts

@@ -2,11 +2,39 @@ import GenericFunction from "../../GenericFunction";
 
 export interface OwnedThroughMetadata {
   fkColumn: string;
-  parentModel: GenericFunction;
+  /*
+   * The parent resource type(s) whose ownership grants access to this
+   * model's rows. Usually one (e.g. Monitor), but a polymorphic FK can
+   * inherit ownership from several resource types — e.g. a telemetry
+   * row's serviceId may reference a Service, Host, DockerHost or
+   * KubernetesCluster, so Owned scope unions the owned ids across all of
+   * them.
+   */
+  parentModels: Array<GenericFunction>;
+  /*
+   * When true, rows whose fkColumn equals the tenant (project) id itself
+   * are also visible under Owned scope. Telemetry with no owning resource
+   * (the unattributed "Unknown" bucket) is tagged with the projectId in
+   * place of a resource id; it belongs to the project, not any single
+   * owner, so every in-project user with the table permission may see it.
+   */
+  includeProjectScope: boolean;
 }
 
-export default (fkColumn: string, parentModel: GenericFunction) => {
+export interface OwnedThroughOptions {
+  includeProjectScope?: boolean;
+}
+
+export default (
+  fkColumn: string,
+  parentModel: GenericFunction | Array<GenericFunction>,
+  options?: OwnedThroughOptions,
+) => {
   return (ctr: GenericFunction) => {
-    ctr.prototype.ownedThrough = { fkColumn, parentModel };
+    ctr.prototype.ownedThrough = {
+      fkColumn,
+      parentModels: Array.isArray(parentModel) ? parentModel : [parentModel],
+      includeProjectScope: options?.includeProjectScope ?? false,
+    };
   };
 };

package/Types/Telemetry/ServiceType.ts

@@ -14,6 +14,16 @@ enum ServiceType {
   Host = "Host",
   DockerHost = "DockerHost",
   KubernetesCluster = "KubernetesCluster",
+  /*
+   * Telemetry that arrived without an OTel service.name and with no
+   * host / docker / k8s resource signal. Instead of synthesising a
+   * placeholder "Unknown Service" Postgres row (which collected every
+   * oneuptime.label.* attribute from unrelated sources), the row's
+   * `serviceId` slot holds the projectId and no Service row is created.
+   * The read side renders these under a synthetic "Unknown Service"
+   * bucket.
+   */
+  Unknown = "Unknown",
 }
 
 export default ServiceType;

package/UI/Components/AutocompleteTextInput/AutocompleteTextInput.tsx

@@ -29,7 +29,13 @@ export interface ComponentProps {
 const BASE_INPUT_CLASS: string =
   "block w-full rounded-md border border-gray-300 bg-white py-2 pl-3 pr-3 text-sm placeholder-gray-500 focus:border-indigo-500 focus:text-gray-900 focus:placeholder-gray-400 focus:outline-none focus:ring-1 focus:ring-indigo-500 sm:text-sm";
 
-const MAX_SUGGESTIONS: number = 50;
+/*
+ * Aligned with the server-side attribute-value limit (ATTRIBUTE_VALUES_LIMIT)
+ * so that when suggestions are fetched server-side (and already narrowed by
+ * search text), the dropdown can show the full returned set rather than
+ * truncating it further on the client.
+ */
+const MAX_SUGGESTIONS: number = 100;
 
 // Provides a free-form text input with an optional suggestion dropdown.
 const AutocompleteTextInput: FunctionComponent<ComponentProps> = (

package/UI/Components/Dictionary/Dictionary.tsx

@@ -39,6 +39,12 @@ export interface ComponentProps {
   onKeySelected?: ((key: string) => void) | undefined;
   isLoadingKeys?: boolean | undefined;
   loadingValueKeys?: Array<string> | undefined;
+  /*
+   * Called (with the row's key and the current value text) as the user
+   * types in the value input, so the parent can fetch refined value
+   * suggestions server-side. Debouncing is the parent's responsibility.
+   */
+  onValueSearch?: ((key: string, searchText: string) => void) | undefined;
   /*
    * When true, render an operator dropdown (=, !=, contains, etc.)
    * between the key and value inputs. Defaults to false for backwards
@@ -393,6 +399,19 @@ const DictionaryForm: FunctionComponent<ComponentProps> = (
                       newData[index]!.value = value;
                       setData(newData);
                       onDataChange(newData);
+
+                      /*
+                       * Let the parent refine value suggestions server-side
+                       * as the user types. Skip numeric operators — those
+                       * have no value suggestions to narrow.
+                       */
+                      if (
+                        props.onValueSearch &&
+                        item.key &&
+                        !operatorOption.expectsNumericValue
+                      ) {
+                        props.onValueSearch(item.key, value);
+                      }
                     }}
                   />
                 )}

package/UI/Components/Filters/FiltersForm.tsx

@@ -186,6 +186,7 @@ const FiltersForm: FiltersFormFunction = <T extends GenericObject>(
                   onJsonKeySelected={filter.onJsonKeySelected}
                   isLoadingJsonKeys={filter.isLoadingJsonKeys}
                   loadingJsonValueKeys={filter.loadingJsonValueKeys}
+                  onJsonValueSearch={filter.onJsonValueSearch}
                   enableOperators={filter.jsonEnableOperators}
                 />
               </div>

package/UI/Components/Filters/JSONFilter.tsx

@@ -17,6 +17,7 @@ export interface ComponentProps<T extends GenericObject> {
   onJsonKeySelected?: ((key: string) => void) | undefined;
   isLoadingJsonKeys?: boolean | undefined;
   loadingJsonValueKeys?: Array<string> | undefined;
+  onJsonValueSearch?: ((key: string, searchText: string) => void) | undefined;
   enableOperators?: boolean | undefined;
 }
 
@@ -38,6 +39,7 @@ const JSONFilter: JSONFilterFunction = <T extends GenericObject>(
         onKeySelected={props.onJsonKeySelected}
         isLoadingKeys={props.isLoadingJsonKeys}
         loadingValueKeys={props.loadingJsonValueKeys}
+        onValueSearch={props.onJsonValueSearch}
         enableOperators={props.enableOperators}
         addButtonSuffix={filter.title}
         keyPlaceholder={"Key"}

package/UI/Components/Filters/Types/Filter.ts

@@ -12,6 +12,7 @@ export default interface Filter<T extends GenericObject> {
   onJsonKeySelected?: ((key: string) => void) | undefined;
   isLoadingJsonKeys?: boolean | undefined;
   loadingJsonValueKeys?: Array<string> | undefined;
+  onJsonValueSearch?: ((key: string, searchText: string) => void) | undefined;
   jsonEnableOperators?: boolean | undefined;
   isAdvancedFilter?: boolean | undefined;
 }

package/UI/Components/LogsViewer/LogsViewer.tsx

@@ -60,6 +60,8 @@ import { queryStringToFilter } from "../../../Types/Log/LogQueryToFilter";
 import RangeStartAndEndDateTime from "../../../Types/Time/RangeStartAndEndDateTime";
 import TimeRange from "../../../Types/Time/TimeRange";
 import { exportLogs, LogExportFormat } from "../../Utils/LogExport";
+import ProjectUtil from "../../Utils/Project";
+import TelemetryServiceUtil from "../../Utils/TelemetryService";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
 
@@ -460,6 +462,20 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
           services[service.id.toString()] = service;
         });
 
+        /*
+         * Logs without a service.name are tagged with the projectId
+         * (ServiceType.Unknown) and have no Service row. Register a
+         * synthetic "Unknown Service" keyed by the projectId so the
+         * serviceId -> name resolution and the serviceId facet render
+         * "Unknown Service" instead of a raw id. Harmless when no logs
+         * are unattributed — nothing resolves against it.
+         */
+        const projectId: ObjectID | null = ProjectUtil.getCurrentProjectId();
+        if (projectId) {
+          services[projectId.toString()] =
+            TelemetryServiceUtil.getUnknownService(projectId);
+        }
+
         const hostsById: Dictionary<Host> = {};
         hosts.data.forEach((host: Host) => {
           if (!host.id) {

package/UI/Utils/Project.ts

@@ -12,6 +12,7 @@ import SubscriptionStatus, {
 } from "../../Types/Billing/SubscriptionStatus";
 import Navigation from "./Navigation";
 import SessionStorage from "./SessionStorage";
+import Telemetry from "./Telemetry/Telemetry";
 
 export default class ProjectUtil {
   public static getCurrentProjectId(): ObjectID | null {
@@ -107,6 +108,11 @@ export default class ProjectUtil {
     }
     LocalStorage.setItem(`project_${currentProjectId}`, project);
     SessionStorage.setItem(`current_project_id`, currentProjectId);
+
+    // Keep RUM span context in sync with the project being viewed.
+    if (currentProjectId) {
+      Telemetry.setGlobalAttributes({ projectId: currentProjectId });
+    }
   }
 
   public static clearCurrentProject(): void {

package/UI/Utils/Telemetry/Telemetry.ts

@@ -19,7 +19,65 @@ import type { SpanExporter as WebSpanExporter } from "@opentelemetry/sdk-trace-w
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import URL from "../../../Types/API/URL";
 
+/*
+ * Mutable, module-level bag of attributes stamped onto every browser span.
+ * Populated by `Telemetry.setGlobalAttributes` once the signed-in user and
+ * the project being viewed are known (RUM context).
+ */
+const globalSpanAttributes: { [key: string]: string } = {};
+
+interface MutableSpanLike {
+  setAttribute(key: string, value: string): unknown;
+}
+
+/**
+ * Stamps the global RUM attributes (userId, projectId, ...) onto each span at
+ * creation, mirroring the server-side ContextSpanProcessor.
+ */
+class GlobalAttributeSpanProcessor {
+  public onStart(span: MutableSpanLike): void {
+    for (const key in globalSpanAttributes) {
+      const value: string | undefined = globalSpanAttributes[key];
+
+      if (value) {
+        span.setAttribute(key, value);
+      }
+    }
+  }
+
+  public onEnd(): void {
+    // no-op
+  }
+
+  public forceFlush(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public shutdown(): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
 export default class Telemetry {
+  /**
+   * Set RUM attributes that should be attached to every browser span from now
+   * on (e.g. userId, projectId). Safe to call before or after `init`; empty
+   * values are ignored.
+   */
+  public static setGlobalAttributes(attributes: {
+    userId?: string | undefined;
+    projectId?: string | undefined;
+    [key: string]: string | undefined;
+  }): void {
+    for (const key in attributes) {
+      const value: string | undefined = attributes[key];
+
+      if (value) {
+        globalSpanAttributes[key] = value;
+      }
+    }
+  }
+
   public static init(data: { serviceName: string }): void {
     if (DisableTelemetry) {
       return;
@@ -49,6 +107,13 @@ export default class Telemetry {
 
       provider.addSpanProcessor(new BatchSpanProcessor(webTraceExporter));
 
+      // Stamp global RUM attributes (userId, projectId, ...) onto every span.
+      provider.addSpanProcessor(
+        new GlobalAttributeSpanProcessor() as unknown as Parameters<
+          WebTracerProvider["addSpanProcessor"]
+        >[0],
+      );
+
       provider.register({
         contextManager: new ZoneContextManager(),
       });

package/UI/Utils/TelemetryService.ts

@@ -0,0 +1,150 @@
+import Service from "../../Models/DatabaseModels/Service";
+import { Gray500 } from "../../Types/BrandColors";
+import ObjectID from "../../Types/ObjectID";
+import ServiceType from "../../Types/Telemetry/ServiceType";
+
+/*
+ * Telemetry that arrives without an OTel service.name (and with no
+ * host / docker / k8s resource signal) is not backed by a Service row.
+ * The ingest path tags those analytics rows with the projectId in the
+ * `serviceId` column under ServiceType.Unknown (see
+ * OtelIngestBaseService.resolveTelemetryResource). The read side has no
+ * Service to resolve, so we represent that telemetry with a synthetic,
+ * non-persisted Service whose id is the projectId — that way the
+ * existing serviceId -> Service lookups in the telemetry views resolve
+ * it to a labelled "Unknown Service" entry without any per-view special
+ * casing. A real Service._id is never equal to a projectId, so this
+ * never collides with a genuine service.
+ */
+export const UNKNOWN_SERVICE_NAME: string = "Unknown Service";
+
+/*
+ * Result of resolving a telemetry row's polymorphic (serviceId,
+ * serviceType) to something renderable. Either a Service (a real
+ * OpenTelemetry service, or the synthetic "Unknown Service" for the
+ * unattributed bucket) — or a plain `label` for infrastructure resource
+ * types (Host / DockerHost / KubernetesCluster) that have no Service row.
+ */
+export interface ResolvedTelemetryResource {
+  service?: Service;
+  label?: string;
+}
+
+export default class TelemetryServiceUtil {
+  /*
+   * True when a telemetry row's serviceId is the synthetic "Unknown
+   * Service" — i.e. it equals the projectId (ServiceType.Unknown). Used
+   * to suppress navigation to a per-service detail page that does not
+   * exist for unattributed telemetry.
+   */
+  public static isUnknownServiceId(
+    serviceId: ObjectID | string | null | undefined,
+    projectId: ObjectID | null | undefined,
+  ): boolean {
+    if (!serviceId || !projectId) {
+      return false;
+    }
+    return serviceId.toString() === projectId.toString();
+  }
+
+  /*
+   * Build the synthetic Service used to render unattributed telemetry.
+   * Not persisted — id is the projectId so that serviceId -> Service
+   * lookups (which key on the analytics row's serviceId) resolve to it.
+   */
+  public static getUnknownService(projectId: ObjectID): Service {
+    const service: Service = new Service();
+    service.id = projectId;
+    service.name = UNKNOWN_SERVICE_NAME;
+    service.serviceColor = Gray500;
+    return service;
+  }
+
+  /*
+   * Resolve a telemetry row's polymorphic (serviceId, serviceType) to a
+   * renderable resource, given the project's loaded Services. Replaces the
+   * old server-side `service` ORM relation on TelemetryException: a real
+   * Service resolves from the loaded list, the unattributed bucket resolves
+   * to the synthetic "Unknown Service", and Host / DockerHost /
+   * KubernetesCluster resolve to a type label (no Service row exists for
+   * them). Mirrors how the ClickHouse analytics rows are resolved.
+   */
+  public static resolveTelemetryResource(data: {
+    serviceId: ObjectID | string | null | undefined;
+    serviceType: ServiceType | string | null | undefined;
+    services: Array<Service>;
+    projectId: ObjectID | null | undefined;
+  }): ResolvedTelemetryResource {
+    const serviceIdStr: string | undefined = data.serviceId?.toString();
+
+    // Real Service (OpenTelemetry) — resolve from the loaded list.
+    if (serviceIdStr) {
+      const found: Service | undefined = data.services.find((s: Service) => {
+        return s.id?.toString() === serviceIdStr;
+      });
+      if (found) {
+        return { service: found };
+      }
+    }
+
+    // Unattributed (Unknown) bucket — serviceId is the projectId.
+    if (
+      data.projectId &&
+      (data.serviceType === ServiceType.Unknown ||
+        this.isUnknownServiceId(data.serviceId, data.projectId))
+    ) {
+      return { service: this.getUnknownService(data.projectId) };
+    }
+
+    // Infrastructure resource types — no Service row; render a type label.
+    const typeLabels: Record<string, string> = {
+      [ServiceType.Host]: "Host telemetry",
+      [ServiceType.DockerHost]: "Docker host telemetry",
+      [ServiceType.KubernetesCluster]: "Kubernetes telemetry",
+    };
+    const label: string | undefined = data.serviceType
+      ? typeLabels[data.serviceType.toString()]
+      : undefined;
+    if (label) {
+      return { label: label };
+    }
+
+    return { label: "Unknown" };
+  }
+
+  /*
+   * Append the synthetic "Unknown Service" to a loaded service list, but
+   * only when the telemetry in view actually references it (some
+   * serviceId equals the projectId). Avoids showing an empty "Unknown
+   * Service" entry for projects that always set service.name. Idempotent.
+   */
+  public static withUnknownServiceIfReferenced(data: {
+    services: Array<Service>;
+    referencedServiceIds: Iterable<string>;
+    projectId: ObjectID;
+  }): Array<Service> {
+    const projectIdStr: string = data.projectId.toString();
+
+    let isReferenced: boolean = false;
+    for (const id of data.referencedServiceIds) {
+      if (id === projectIdStr) {
+        isReferenced = true;
+        break;
+      }
+    }
+
+    if (!isReferenced) {
+      return data.services;
+    }
+
+    const alreadyPresent: boolean = data.services.some((service: Service) => {
+      return service.id?.toString() === projectIdStr;
+    });
+
+    if (alreadyPresent) {
+      return data.services;
+    }
+
+    return [...data.services, this.getUnknownService(data.projectId)];
+  }
+}

package/build/dist/Models/AnalyticsModels/ExceptionInstance.js

@@ -785,7 +785,7 @@ let ExceptionInstance = class ExceptionInstance extends AnalyticsBaseModel {
 };
 ExceptionInstance = __decorate([
     OperationalResource(),
-    OwnedThrough("serviceId", Service),
+    OwnedThrough("serviceId", Service, { includeProjectScope: true }),
     __metadata("design:paramtypes", [])
 ], ExceptionInstance);
 export default ExceptionInstance;